import websocketService from './websocket.js';

/**
 * WebSocket AI服务
 * 实现基于WebSocket的实时AI对话功能，类似ChatGPT的流式输出体验
 */

// 记录当前会话ID
let sessionId = '';

// 消息处理回调函数
let messageHandler = null;

/**
 * 初始化WebSocket AI服务
 * @param {Object} options - 配置选项
 * @param {Function} options.onMessage - 消息回调函数，接收参数(message, isEnd)
 * @param {Function} options.onConnected - 连接成功回调函数
 * @param {Function} options.onDisconnected - 连接断开回调函数
 * @param {Function} options.onError - 错误回调函数
 * @returns {Promise} - 返回Promise对象
 */
export const initAiWsService = (options = {}) => {
    return new Promise((resolve, reject) => {
        try {
            messageHandler = options.onMessage;
            
            websocketService.initWebSocket({
                onMessage: (message) => {
                    handleWsMessage(message);
                },
                onOpen: () => {
                    console.log('AI WebSocket服务已连接');
                    if (options.onConnected) options.onConnected();
                    resolve();
                },
                onClose: () => {
                    console.log('AI WebSocket服务已断开');
                    if (options.onDisconnected) options.onDisconnected();
                },
                onError: (error) => {
                    console.error('AI WebSocket服务错误:', error);
                    if (options.onError) options.onError(error);
                    reject(error);
                },
                onReconnect: () => {
                    console.log('AI WebSocket服务重连中...');
                }
            });
        } catch (error) {
            console.error('初始化AI WebSocket服务失败:', error);
            reject(error);
        }
    });
};

/**
 * 处理WebSocket消息
 * @param {Object} message - 收到的消息
 */
const handleWsMessage = (message) => {
    if (!message) return;
    
    try {
        // 根据消息类型处理
        if (typeof message === 'string') {
            // 尝试解析为JSON
            try {
                const parsedMessage = JSON.parse(message);
                processMessage(parsedMessage);
            } catch (e) {
                // 如果不是JSON，则作为普通文本消息处理
                if (messageHandler) {
                    messageHandler(message, false, false);
                }
            }
        } else {
            // 已经是对象格式
            processMessage(message);
        }
    } catch (error) {
        console.error('处理WebSocket消息失败:', error);
    }
};

/**
 * 处理消息对象
 * @param {Object} message - 消息对象
 */
const processMessage = (message) => {
    // 根据消息类型处理
    switch (message.type) {
        case 'chat':
        case 'message':
            // 聊天消息
            handleChatMessage(message);
            break;
        case 'error':
            // 错误消息
            console.error('AI服务错误:', message.error || message.content);
            if (messageHandler) {
                messageHandler(message.error || message.content, true, true);
            }
            break;
        case 'done':
            // 消息完成
            if (messageHandler) {
                messageHandler('', true, false);
            }
            break;
        case 'system':
            // 系统消息
            console.log('AI系统消息:', message.content);
            break;
        default:
            // 默认假设为流式输出的内容片段
            if (message.content || message.text || message.delta) {
                const content = message.content || message.text || message.delta;
                if (messageHandler) {
                    messageHandler(content, false, false);
                }
            } else {
                console.log('未知消息格式:', message);
            }
    }
};

/**
 * 处理聊天消息
 * @param {Object} message - 聊天消息
 */
const handleChatMessage = (message) => {
    if (!messageHandler) return;
    
    // 设置会话ID
    if (message.sessionId) {
        sessionId = message.sessionId;
    }
    
    // 获取消息内容
    const content = message.content || message.text || (message.delta ? message.delta.content : '') || '';
    
    // 判断是否结束
    const isEnd = message.isEnd || message.done || false;
    
    // 判断是否错误
    const isError = message.isError || message.error || false;
    
    // 调用消息处理函数
    messageHandler(content, isEnd, isError);
};

/**
 * 发送AI聊天消息
 * @param {Object} params - 聊天参数
 * @param {String} params.message - 用户消息
 * @param {String} params.sessionId - 会话ID，可选，不提供则使用当前会话ID
 * @returns {Promise} - 返回Promise对象
 */
export const sendAiChatMessage = (params) => {
    return new Promise((resolve, reject) => {
        try {
            // 构建消息数组
            const messages = [
                {
                    role: "user",
                    content: params.message
                }
            ];
            
            // 如果有会话ID，添加到消息中
            if (params.sessionId || sessionId) {
                messages.push({
                    role: "system",
                    content: `Session ID: ${params.sessionId || sessionId}`
                });
            }
            
            // 构建WebSocket消息体
            const message = {
                type: 'batchV3',
                model: 'ep-20250204190620-9n94t', // 默认模型，可以通过参数传入
                message: JSON.stringify(messages),
                agentId: params.agentId || '',
                config: params.config || {}
            };
            
            // 发送消息
            websocketService.sendMessage(message)
                .then(resolve)
                .catch(reject);
        } catch (error) {
            console.error('发送AI聊天消息失败:', error);
            reject(error);
        }
    });
};

/**
 * 清空当前会话
 * @returns {Promise} - 返回Promise对象
 */
export const clearAiChatSession = () => {
    return new Promise((resolve, reject) => {
        try {
            // 构建消息体
            const message = {
                type: 'clear',
                sessionId: sessionId,
                timestamp: Date.now()
            };
            
            // 发送消息
            websocketService.sendMessage(message)
                .then((res) => {
                    // 清空会话ID
                    sessionId = '';
                    resolve(res);
                })
                .catch(reject);
        } catch (error) {
            console.error('清空AI聊天会话失败:', error);
            reject(error);
        }
    });
};

/**
 * 关闭WebSocket AI服务
 */
export const closeAiWsService = () => {
    websocketService.closeWebSocket();
    sessionId = '';
    messageHandler = null;
};

export default {
    initAiWsService,
    sendAiChatMessage,
    clearAiChatSession,
    closeAiWsService
}; 